
const mLans = ['en', 'zh']

let mIl8n = null

let onLoadText = (lan, data)=>
{
    try{

        let d = JSON.parse(data)
        if (!d)
        {
            return false
        }
        
        !i18n && (i18n = {})
        
        !i18n.languages && (i18n.languages = {})
        
        i18n.languages[lan] = d

        mIl8n.inst.replace(d)
    }
    catch(e)
    {
        Log.e("LocalizeService", "parse file fail: "  + e)
        
        return false
    }

    return true
}

let load = (lan, file, callback) =>
{
    ogre.loadResource('lans/'+ file, null, 3,
        (data) =>{
            
            if (data)
            {
                if (callback)
                {
                    callback(onLoadText(lan, data))
                }
                else
                {
                    onLoadText(lan, data)
                }

                ogre.releaseResource('lans/'+ file)
            }
            else
            {
                callback && callback(false)
            } 
        }
    )
}

let replace = (str, type, value) =>
{
    if (type === 'number')
    {
        return str.replace('%d', value)
    }
    else if (type === 'string')
    {
        return str.replace('%s', value)
    }

    return str
}

let LocalizeService = 
{
    init(callback)
    {
        let app = require("App")

        const p = require('ConstBase')

        let lan = app.get(p.language)
        if (mLans.indexOf(lan) < 0)
        {
            lan = mLans[0]
            app.set(p.language, lan)
        }

        mIl8n = require('LanguageData')
        
        mIl8n.init(lan)

        load(lan, lan, callback)
    },   

    /**
     * 载入多语言文件
     *
     * @param {String} lan - 多语言名标识
     * @param {String} lan - 多语言文件名称
     * @param {Function} callback(ok) - 结果回调: true or false
     */
    load : load,

    exit(k)
    {
        return mIl8n.t(k) ? true : false
    },

    /**
     * 根据key值，获取多语言文本
     *
     * @param {String} k - key值
     * @return {String} 返回语言文本
     */
    get(k)
    {
        return mIl8n.t(k) || k
    },

    /**
     * 根据key值，格式化获取多语言文本
     *
     * @param {String} k - key值
     * @return {String} 返回语言文本
     */
    format(k) 
    {
        let str = mIl8n.t(k) || k
        
        const num = arguments.length
        
        for (let i = 1; i < num; ++i) 
        {
            str = replace(str, typeof arguments[i], arguments[i])
        }

        return str
    },

    /**
     * 设置当前语言
     *
     * @param {String} lan - 多语言名标识
     */
    setLanguage(lan)
    {
        if (!lan || mLans.indexOf(lan) < 0)
        {
            return
        }

        const p = require('ConstBase')

        require("App").set(p.language, lan)
        
        let ss = require('StorageSystem').share()

        ss.set(p.storge_language, lan, true)
        
        mIl8n.init(lan)
    },

    /**
     * 获取当前语言
     */
    name() 
    {
        return window.i18n.curLang
    },

    languages() 
    {
        return mLans 
    },

    nameByLanguage(lan) 
    {
        if (lan && mLans[lan]) 
        {
            return mLans[lan]
        }
        return lan && mLans[lan] ? mLans[lan] : ""
    }
}

module.exports = LocalizeService

